package com.agile.springboot.service.impl;

import com.agile.springboot.service.UserService;
import com.agile.springboot.dao.GroupMapper;
import com.agile.springboot.dao.QuestionAnsweredMapper;
import com.agile.springboot.dao.QuestionnaireMapper;
import com.agile.springboot.dao.UserMapper;
import com.agile.springboot.entity.Group;
import com.agile.springboot.entity.Questionnaire;
import com.agile.springboot.entity.QuestionAnswered;
import com.agile.springboot.entity.User;
import com.agile.springboot.utils.DateUtil;
import com.agile.springboot.utils.UUIDUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.*;

@Service
public class UserServiceImpl implements UserService {

    @Resource
    UserMapper userMapper;
    @Resource
    GroupMapper groupMapper;
    @Resource
    QuestionnaireMapper questionnaireMapper;
    @Resource
    QuestionAnsweredMapper questionAnsweredMapper;

    /**
     * 新增用户
     * @param user 用户实体
     * @return 返回值为1，则说明新增用户成功
     */
    @Override
    public int addUser(User user){
        user.setCreation_date(DateUtil.getCreateTime());
        user.setIs_deleted(0);//逻辑删除默认值为0
        user.setId(UUIDUtil.getOneUUID());
        return userMapper.insert(user);
    }

    /**
     * 逻辑删除用户，被删除对象的 is_deleted 值变成 1
     * @param user_id 用户id
     * @return 返回值为1，则说明逻辑删除成功
     */
    @Override
    public int deleteUser(String user_id){
        return userMapper.deleteById(user_id);
    }

    /**
     * 物理删除用户
     * @param user_id 用户id
     * @return 返回值为1，则说明物理删除成功
     */
    @Override
    public int pscDeleteUser(String user_id){
        return userMapper.pscDeleteById(user_id);
    }

    /**
     * 修改用户信息
     * @param user 用户实体
     * @return 返回值为1，则说明修改用户信息成功
     */
    @Override
    public int updateUser(User user){
        Date date = new Date();
        user.setLast_update_date(date);
        return userMapper.updateById(user);
    }

    /**
     * 模糊搜索用户
     * @param user_name 用户名
     * @param identity 用户身份信息
     * @return List<User> 用户列表
     */
    @Override
    public List<User> searchUser(String user_name,int identity){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        List<User> userList = userMapper.selectList(queryWrapper.like(user_name!=null,"username", user_name).eq("identity",identity));
        return userList;
    }

    /**
     * 精准搜索用户——根据用户名
     * @param user_name 用户名
     * @return User实体
     */
    @Override
    public User findUser(String user_name){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        return userMapper.selectOne(queryWrapper.eq("username",user_name));
    }

    /**
     * 精准搜索用户——根据用户 id
     * @param id 用户id
     * @return User实体
     */
    @Override
    public User searchUserById(String id){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        return userMapper.selectOne(queryWrapper.eq("id",id));
    }

    /**
     * 管理员查询所有租户的费用情况
     * @return Map(key:租户, value:该租户所对应的费用)
     */
    @Override
    public Map<User, String> calculateCost(){

        Map<User, String> map_tenant = new HashMap<>();//最终要返回的结果：Map(key:租户, value:该租户所对应的费用)
        QueryWrapper<User> queryWrapper_user1 = new QueryWrapper<>();
        List<User> tenants = userMapper.selectList(queryWrapper_user1.eq("identity",1));//获取所有的租户，其identity为1。

        for(User tenant : tenants){

            double money=0;//总费用
            int number_group=0;//群组数量
            int number_questionnaire=0;//问卷数量
            int number_answer=0;//答卷数量
            QueryWrapper<User> queryWrapper_user2 = new QueryWrapper<>();//由于QueryWrapper在第二次使用时，会出现查询结果为空（来回试了好多次），所以在这里重新new一个对象
            Map<String,Object> map_user = new HashMap<>();
            map_user.put("identity",2);//用户的identity为2。
            map_user.put("parent_id",tenant.getId());
            List<User> theTenant_users = userMapper.selectList(queryWrapper_user2.allEq(map_user));//获取属于当前租户的所有用户
            for(User theTenant_user : theTenant_users){

                //根据当前用户的id查找其创建的所有群组。
                QueryWrapper<Group> queryWrapper_group = new QueryWrapper<>();
                List<Group> theTenant_theUser_groups = groupMapper.selectList(queryWrapper_group.eq("created_by",theTenant_user.getId()));
                number_group = number_group + theTenant_theUser_groups.size();

                //根据当前用户的id查找其创建的所有问卷。
                QueryWrapper<Questionnaire> queryWrapper_questionnaire = new QueryWrapper<>();
                List<Questionnaire> theTenant_theUser_questionnaires = questionnaireMapper.selectList(queryWrapper_questionnaire.eq("user_id",theTenant_user.getId()));
                number_questionnaire = number_questionnaire + theTenant_theUser_questionnaires.size();

                for(Questionnaire theTenant_theUser_questionnaire : theTenant_theUser_questionnaires){

                    //根据问卷id查找其包含的所有答卷中包含的所答题目。
                    QueryWrapper<QuestionAnswered> queryWrapper_answered = new QueryWrapper<>();
                    List<QuestionAnswered> theTenant_theUser_theQuestionnaire_questionAnswered = questionAnsweredMapper.selectList(queryWrapper_answered.eq("questionnaire_id",theTenant_theUser_questionnaire.getId()));
                    //根据所答题目的 questionnaire_answered_id 统计答卷的数量
                    HashSet<String> set = new HashSet<>();
                    for(QuestionAnswered questionAnswered : theTenant_theUser_theQuestionnaire_questionAnswered){
                        set.add(questionAnswered.getQuestionnaire_answered_id());
                    }
                    number_answer = number_answer + set.size();
                }
            }
            //群组费用每个1元，问卷费用每份0.5元，答卷费用每份0.1元
            money = number_group*1 + number_questionnaire*0.5 + number_answer*0.1;
            map_tenant.put(tenant,money+"");
        }
        return map_tenant;
    }

    /**
     * 查询当前租户创建的所有用户——根据当前租户id 或 查询当前用户创建的所有答者——根据当前用户id
     * @param user_id 租户id 或 用户id
     * @return List<User> 该租户创建的所有用户 或 该用户创建的所有答者
     */
    @Override
    public List<User> queryChildrenCreatedByParent(String user_id){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        Map<String,Object> map = new HashMap<>();
        map.put("parent_id",user_id);
        return userMapper.selectList(queryWrapper.allEq(map));
    }
}
